Adaptive online deployment for resource constrained mobile smart clients

Nowadays mobile devices are more and more used as a platform for applications. Contrary to prior generation handheld devices configured with a predefined set of applications, today leading edge devices provide a platform for flexible and customized application deployment. However, these applications have to deal with the limitations (e.g. CPU speed, memory) of these mobile devices and thus cannot handle complex tasks. In order to cope with the handheld limitations and the ever changing device context (e.g. network connections, remaining battery time, etc.) we present a middleware solution that dynamically offloads parts of the software to the most appropriate server. Without a priori knowledge of the application, the optimal deployment is calculated, that lowers the cpu usage at the mobile client, whilst keeping the used bandwidth minimal. The information needed to calculate this optimum is gathered on the fly from runtime information. Experimental results show that the proposed solution enables effective execution of complex applications in a constrained environment. Moreover, we demonstrate that the overhead from the middleware components is below 2%

Serialization of Distributed Execution-state in Java

In this paper we present a mechanism for serializing the executionstate of a distributed Java application that is implemented on a conventional Object Request Broker (ORB) architecture such as Java Remote Method Invocation (RMI). To support capturing and reestablishment of distributed execution-state, we developed a byte code transformer that adds this functionality to a Java application by extracting execution-state from the application code. An important benefit of the serialization mechanism is its portability. It can transparently be integrated into any legacy Java application

Securing Web Service Compositions: Formalizing Authorization policies using Event Calculus

Abstract. Service composition is a fundamental technique for developing Web services based applications. As autonomous services are invoked through protocols, issues such as security must be taken into account. Thus, ensuring security in such a system is challenging and not supported by most of the security frameworks proposed in current literature. This paper presents a formal model for composing security policies dynamically to cope with changes in requirements or occurrences of events. We address one particular issue- that of authorization within a Web services composition. In particular, we propose a dynamic authorization model which allows for complex authorization policies whilst ensuring trust and privacy between the components services.

Reflex - Towards an Open Reflective Extension of Java

Abstract. Since version 1.1 of the Java Development Kit, the Java reflective facilities have been successively extended. However, they still prove to be limited. A number of systems (e.g. MetaXa, Guaraná, Kava, Javassist) have addressed this limitation by providing reflective extensions of Java with richer MetaObject Protocols (MOPs). All these extensions provide a particular infrastructure that reflects the commitment of the designer to particular trade-offs between efficiency, portability, expressiveness and flexibility. Unfortunately, these trade-offs are not satisfactory for all applications, since different applications may have different needs. This calls for breaking down the building of a reflective extension into different components that can be specialized in order to fit specific needs. We qualify such a reflective extension as open. In this paper, we present Reflex, a prototype open reflective extension of Java. As such, Reflex is a working reflective extension implemented by composing basic building blocks organized following a framework. Reflex comprises the definition of the framework, default generic components and some specialized components.

Safely Composable Type-Specific Languages

Abstract. Programming languages often include specialized syntax for com-mon datatypes (e.g. lists) and some also build in support for specific special-ized datatypes (e.g. regular expressions), but user-defined types must use general-purpose syntax. Frustration with this causes developers to use strings, rather than structured data, with alarming frequency, leading to correctness, performance, security, and usability issues. Allowing library providers to modularly extend a language with new syntax could help address these issues. Unfortunately, prior mechanisms either limit expressiveness or are not safely composable: individ-ually unambiguous extensions can still cause ambiguities when used together. We introduce type-specific languages (TSLs): logic associated with a type that determines how the bodies of generic literals, able to contain arbitrary syntax, are parsed and elaborated, hygienically. The TSL for a type is invoked only when a literal appears where a term of that type is expected, guaranteeing non-interference. We give evidence supporting the applicability of this approach and formally specify it with a bidirectionally typed elaboration semantics for the Wyvern programming language